Reflection in C# is a powerful feature that allows you to inspect, analyze, and even modify the structure of your code (like classes, methods, properties, etc.) at runtime. It’s part of the System.Reflection namespace.

What is Reflection?

Reflection allows your program to:

1. Inspect assemblies
2. Examine types (classes, interfaces, structs)
3. Access metadata (attributes, method info)
4. Dynamically create instances
5. Invoke methods and access properties/fields

It's widely used in:

1. Frameworks like Entity Framework, ASP.NET MVC
2. Serialization/Deserialization
3. Unit Testing
4. Plugins and dynamic module loading

Namespaces Required

using System;
using System.Reflection;

Basic Example

using System;
using System.Reflection;

class Person
{
    public string Name { get; set; }

    public void SayHello()
    {
        Console.WriteLine("Hello!");
    }
}

class Program
{
    static void Main()
    {
        Type type = typeof(Person); // Get type info

        Console.WriteLine("Class Name: " + type.Name);

        Console.WriteLine("\nProperties:");
        foreach (PropertyInfo prop in type.GetProperties())
        {
            Console.WriteLine(prop.Name);
        }

        Console.WriteLine("\nMethods:");
        foreach (MethodInfo method in type.GetMethods())
        {
            Console.WriteLine(method.Name);
        }
    }
}

Common Reflection Classes

Getting Type Info

Type t1 = typeof(Person); // Compile time
Type t2 = obj.GetType();  // Runtime
Type t3 = Type.GetType("Namespace.Person");

Invoking a Method via Reflection

Person p = new Person();
MethodInfo method = typeof(Person).GetMethod("SayHello");
method.Invoke(p, null); // Calls SayHello on p

Accessing Fields & Properties

PropertyInfo prop = typeof(Person).GetProperty("Name");
prop.SetValue(p, "Alice");
Console.WriteLine(prop.GetValue(p)); // Output: Alice

Creating Objects Dynamically

Type type = typeof(Person);
object obj = Activator.CreateInstance(type); // Creates new Person()

MethodInfo method = type.GetMethod("SayHello");
method.Invoke(obj, null);

Reading Attributes

[Obsolete("Use NewClass instead")]
class OldClass { }

Type type = typeof(OldClass);
object[] attrs = type.GetCustomAttributes(false);
foreach (object attr in attrs)
{
    Console.WriteLine(attr);
}

Reflection Limitations

1. Performance: Slower than direct access.
2. Security: Can bypass encapsulation.
3. Complexity: Harder to maintain/debug.

Summary

Reflection gives C# incredible flexibility and power, especially for frameworks and tools. But use it wisely — only when necessary — to avoid complexity and performance issues.

Read More -

• Access attributes using reflection